package com.gwtjs.service.impl;

import java.io.Serializable;
import java.util.List;

import org.hibernate.LockMode;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Service;

import com.gwtjs.dao.GenericDao;
import com.gwtjs.model.Pager;
import com.gwtjs.model.QueryCondition;
import com.gwtjs.service.BussnessService;

@Service("bussnessService")
@Scope("prototype")
public abstract class BussnessServiceImpl<T extends Serializable, PK extends Serializable>
		implements BussnessService<T, PK> {
	@Autowired
	@Qualifier
	protected GenericDao<T, PK> entityDao;

	/**
	 * 取实体最大ID值
	 */
	public Integer getMaxObjectId(final Class<T> entity) {
		return entityDao.getMaxObjectId(entity);
	}

	/**
	 * 新增或修改
	 * 
	 * @param e
	 */
	public void saveOrUpdate(T e) {
		entityDao.saveOrUpdate(e);
	}

	public void save(T e) {
		entityDao.save(e);
	}

	public void update(T e) {
		entityDao.update(e);
	}

	/**
	 * 批量保存
	 * 
	 * @param list
	 */
	public void saveBulk(List<T> list) {
		entityDao.saveBulk(list);
	}

	/**
	 * 批量更新
	 * 
	 * @param list
	 */
	public void updateBulk(List<T> list) {
		entityDao.updateBulk(list);
	}

	/**
	 * 删除多条 记录
	 * 
	 * @param entityClass
	 * @param att
	 * @param val
	 */
	public void attrDeletes(Class<T> entityClass, Object att, Object... val) {
		entityDao.attrDeletes(entityClass, att, val);
	}

	/**
	 * 批量删除 ? 待续
	 * 
	 * @param list
	 */
	public void deleteBulk(List<T> list) {
		entityDao.deleteBulk(list);
	}

	public void merge(T e) {
		entityDao.merge(e);
	}

	public void delete(Class<T> entityClass, PK id) {
		entityDao.delete(entityClass, id);
	}

	public void deleteObject(T e) {
		entityDao.deleteObject(e);
	}

	/**
	 * @deprecated 推荐使用 {@link}
	 */
	public void deletes(T e) {
		entityDao.deletes(e);
	}

	
	public T get(Class<T> entityClass, PK id) {
		return entityDao.get(entityClass, id);
	}

	// 根据主键获取实体并加锁。如果没有相应的实体，返回 null。
	
	@Deprecated
	public T getWithLock(Class<T> entityClass, PK id, LockMode lock) {
		return entityDao.getWithLock(entityClass, id, lock);
	}

	/**
	 * 根据查询条件返回唯一一条 记录 或者使用
	 * 
	 * @return 一个实体
	 */
	
	public T get(final Class<T> entityClass, final String propertyName,
			final Object value) {
		return entityDao.get(entityClass, propertyName, value);
	}

	/**
	 * 某标识的对象是否存在
	 * 
	 * @param id
	 * @return
	 */
	public boolean exists(Class<T> entityClass, PK id) {
		return entityDao.exists(entityClass, id);
	}

	/**
	 * 按标识修改一个属性的值
	 * 
	 * @param attr
	 * @param val
	 * @param entity
	 * @param id
	 */
	public void updateAttr(Class<T> entityClass, String attr, Object val, PK id) {
		entityDao.updateAttr(entityClass, attr, val, id);
	}

	/**
	 * <h2>返回总记录数</h2>
	 * <p>
	 * <h3 style="color:#F00">注意：</h3>
	 * 请在排序和分页前提交sql语句,并且WHERE需要大写
	 * </p>
	 * 
	 * @deprecated 此方法暂时没有其它的方法调用
	 * @param sql
	 * @return
	 */
	public int getEntityCount(String sql) {
		return entityDao.getEntityCount(sql);
	}

	/**
	 * <h2>根据属性值查询单个对象</h2>
	 * 
	 * @param entityClass
	 *            实体类名
	 * @param propertyName
	 *            属性名
	 * @param value
	 *            属性值
	 * @return 实体对象
	 */
	
	public T findUniqueByProperty(final Class<T> entityClass,
			final String propertyName, final Object value) {
		return entityDao.findUniqueByProperty(entityClass, propertyName, value);
	}

	/**
	 * <h2>根据属性值查询实体是否存在</h2>
	 * 
	 * @param entityClass
	 *            实体类名
	 * @param propertyName
	 *            参照的属性名
	 * @param value
	 *            属性值
	 * @return 存在则返回true,不存在则返回false
	 */
	public boolean isPropertyExist(final Class<T> entityClass,
			final String propertyName, final Object value) {
		return entityDao.isPropertyExist(entityClass, propertyName, value);
	}

	/*
	 * ------------------------------------ 列表查询
	 * --------------------------------------
	 */

	public Pager<T> findAll(Class<T> entityClass) {
		return entityDao.findAll(entityClass);
	}

	public Pager<T> findAll(Class<T> entityClass, String ascProperty,
			boolean isAsc, int firstResult, int maxResult) {
		return entityDao.findAll(entityClass, ascProperty, isAsc, firstResult, maxResult);
	}

	
	public Pager<T> findAll(Class<T> entityClass, String ascProperty,
			boolean isAsc, int firstResult, int maxResult,
			List<QueryCondition> entities) {
		return entityDao.findAll(entityClass, ascProperty, isAsc, firstResult, maxResult, entities);
	}

	/*
	 * --------------------------------\ 模糊查询 /--------------------------------/
	 */
	/**
	 * 这里需要重新做一下，查询的属性应该是可变数组，值应该是一个
	 */
	@Deprecated
	public Pager<T> findLikeAll(Class<T> entityClass, String ascProperty,
			boolean isAsc, int firstResult, int maxResult,
			List<QueryCondition> entities) {
		return entityDao.findLikeAll(entityClass, ascProperty, isAsc, firstResult, maxResult, entities);
	}

	/*
	 * --------------------------------\ 命名及存储过程查询
	 */

	/**
	 * 命名查询的执行
	 */
	/**
	 * 存储过程的执行
	 */
	
	public Pager<T> namedQuery(Class<T> entityClass, String queryName,
			Object val) {
		return namedQuery(entityClass, queryName, val);
	}
}
